Standard Django URL Pattern:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('movies/', include('movies.urls')),  # ← App URLs einbinden
]

App URLs:

# filepath: movies/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.movie_list, name='movie-list'),           # /movies/
    path('<int:pk>/', views.movie_detail, name='movie-detail'),  # /movies/1/
]

1. path() - Einfache Patterns (Django 2.0+)

from django.urls import path

urlpatterns = [
    # Integer Parameter
    path('movies/<int:pk>/', views.movie_detail),
    # /movies/1/
    
    # String Parameter
    path('movies/<str:slug>/', views.movie_by_slug),
    # /movies/the-matrix/
    
    # UUID Parameter
    path('movies/<uuid:id>/', views.movie_by_uuid),
    # /movies/550e8400-e29b-41d4-a716-446655440000/
    
    # Path Parameter (mehrere Segmente)
    path('files/<path:filepath>/', views.file_detail),
    # /files/docs/2023/report.pdf
]

✅ Vorteile: Einfach, lesbar, typsicher

2. re_path() - RegEx Patterns

from django.urls import re_path

urlpatterns = [
    # Jahr (4 Ziffern)
    re_path(r'^movies/(?P<year>[0-9]{4})/$', views.movies_by_year),
    # /movies/2023/
    
    # Slug (Buchstaben, Zahlen, Bindestriche)
    re_path(r'^movies/(?P<slug>[-\w]+)/$', views.movie_by_slug),
    # /movies/the-matrix-1999/
    
    # Custom Pattern
    re_path(r'^api/v(?P<version>[0-9]+)/movies/$', views.movie_list),
    # /api/v1/movies/, /api/v2/movies/
]

✅ Vorteile: Maximale Flexibilität

❌ Nachteile: Komplexer, fehleranfällig

Views definieren:

# filepath: movies/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Movie
from .serializers import MovieSerializer


class MovieListAPIView(APIView):
    """GET: Liste, POST: Erstellen"""
    
    def get(self, request):
        movies = Movie.objects.all()
        serializer = MovieSerializer(movies, many=True)
        return Response(serializer.data)
    
    def post(self, request):
        serializer = MovieSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class MovieDetailAPIView(APIView):
    """GET: Detail, PUT: Update, DELETE: Löschen"""
    
    def get(self, request, pk):
        movie = get_object_or_404(Movie, pk=pk)
        serializer = MovieSerializer(movie)
        return Response(serializer.data)
    
    def put(self, request, pk):
        movie = get_object_or_404(Movie, pk=pk)
        serializer = MovieSerializer(movie, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
    def delete(self, request, pk):
        movie = get_object_or_404(Movie, pk=pk)
        movie.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

URLs konfigurieren:

# filepath: movies/urls.py
from django.urls import path
from .views import MovieListAPIView, MovieDetailAPIView

urlpatterns = [
    path('movies/', MovieListAPIView.as_view(), name='movie-list'),
    path('movies/<int:pk>/', MovieDetailAPIView.as_view(), name='movie-detail'),
]

Haupt-URLs:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('movies.urls')),  # ← Präfix 'api/'
]

Views definieren:

# filepath: movies/views.py
from rest_framework import generics
from .models import Movie
from .serializers import MovieSerializer


class MovieListCreateView(generics.ListCreateAPIView):
    """GET: Liste, POST: Erstellen"""
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer


class MovieDetailView(generics.RetrieveUpdateDestroyAPIView):
    """GET: Detail, PUT/PATCH: Update, DELETE: Löschen"""
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer

URLs konfigurieren:

# filepath: movies/urls.py
from django.urls import path
from .views import MovieListCreateView, MovieDetailView

urlpatterns = [
    path('movies/', MovieListCreateView.as_view(), name='movie-list'),
    path('movies/<int:pk>/', MovieDetailView.as_view(), name='movie-detail'),
]

ViewSet definieren:

# filepath: movies/views.py
from rest_framework import viewsets
from .models import Movie
from .serializers import MovieSerializer


class MovieViewSet(viewsets.ModelViewSet):
    """
    ViewSet für Movie CRUD-Operationen.
    
    Automatisch bereitgestellt:
    - list(): GET /movies/
    - create(): POST /movies/
    - retrieve(): GET /movies/{pk}/
    - update(): PUT /movies/{pk}/
    - partial_update(): PATCH /movies/{pk}/
    - destroy(): DELETE /movies/{pk}/
    """
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer

Das war's! Nur 3 Zeilen Code! 🚀

SimpleRouter Setup:

# filepath: movies/urls.py
from rest_framework.routers import SimpleRouter
from .views import MovieViewSet

# Router erstellen
router = SimpleRouter()

# ViewSet registrieren
router.register(r'movies', MovieViewSet)

# URLs exportieren
urlpatterns = router.urls

Haupt-URLs:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('movies.urls')),
]

Eigenschaften von SimpleRouter:

• ✅ Minimalistisch
• ✅ Standard REST-Endpoints
• ❌ KEINE Root-API-View
• ❌ Keine trailing slashes ohne Konfiguration

DefaultRouter Setup:

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter
from .views import MovieViewSet, ArtistViewSet

# Router erstellen
router = DefaultRouter()

# ViewSets registrieren
router.register(r'movies', MovieViewSet, basename='movie')
router.register(r'artists', ArtistViewSet, basename='artist')

# URLs exportieren
urlpatterns = router.urls

Root API View - Beispiel Response:

GET /api/

{
    "movies": "http://localhost:8000/api/movies/",
    "artists": "http://localhost:8000/api/artists/"
}

Automatischer basename (Standard):

# filepath: movies/urls.py
router = DefaultRouter()
router.register(r'movies', MovieViewSet)
# ↑ basename wird automatisch aus Model generiert: 'movie'

URL-Namen: movie-list, movie-detail

Manueller basename (erforderlich wenn kein queryset):

# filepath: movies/views.py
class MovieViewSet(viewsets.ModelViewSet):
    serializer_class = MovieSerializer
    
    def get_queryset(self):
        """Dynamisches QuerySet"""
        user = self.request.user
        if user.is_staff:
            return Movie.objects.all()
        return Movie.objects.filter(created_by=user)
    
    # Kein queryset-Attribut!


# filepath: movies/urls.py
router = DefaultRouter()
router.register(r'movies', MovieViewSet, basename='movie')
#                                        ^^^^^^^^^^^^^^^^
# basename MUSS angegeben werden!

Custom basename:

router = DefaultRouter()
router.register(r'my-movies', MovieViewSet, basename='my-movie')
# URL-Namen: 'my-movie-list', 'my-movie-detail'

ViewSet mit Custom Actions:

# filepath: movies/views.py
from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from django.db.models import Avg


class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    @action(detail=False, methods=['get'])
    def top_rated(self, request):
        """
        Top 10 Filme nach Rating
        URL: GET /api/movies/top_rated/
        """
        top_movies = Movie.objects.order_by('-rating')[:10]
        serializer = self.get_serializer(top_movies, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def recent(self, request):
        """
        Filme der letzten 5 Jahre
        URL: GET /api/movies/recent/
        """
        current_year = datetime.now().year
        recent_movies = Movie.objects.filter(year__gte=current_year - 5)
        serializer = self.get_serializer(recent_movies, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['post'])
    def rate(self, request, pk=None):
        """
        Film bewerten
        URL: POST /api/movies/{pk}/rate/
        """
        movie = self.get_object()
        rating = request.data.get('rating')
        
        # Validierung
        if not rating or not (0 <= float(rating) <= 10):
            return Response(
                {'error': 'Rating must be between 0 and 10'},
                status=400
            )
        
        movie.rating = rating
        movie.save()
        
        serializer = self.get_serializer(movie)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def cast(self, request, pk=None):
        """
        Besetzung eines Films
        URL: GET /api/movies/{pk}/cast/
        """
        movie = self.get_object()
        castings = movie.castings.all()
        serializer = MovieCastingSerializer(castings, many=True)
        return Response(serializer.data)

URLs Setup (unverändert!):

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter
from .views import MovieViewSet

router = DefaultRouter()
router.register(r'movies', MovieViewSet)

urlpatterns = router.urls

Alle @action Parameter:

from rest_framework.decorators import action

class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    @action(
        detail=False,                    # Collection (False) oder Member (True)?
        methods=['get', 'post'],         # Erlaubte HTTP-Methoden
        url_path='top-rated',            # Custom URL-Pfad (Standard: Funktionsname)
        url_name='top-rated-movies',     # Custom URL-Name (für reverse)
        permission_classes=[IsAuthenticated],  # Custom Permissions
        serializer_class=TopMovieSerializer,   # Custom Serializer
    )
    def top_rated(self, request):
        """Top-bewertete Filme"""
        # ...
        pass

Beispiele:

class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    # 1. Standard (GET only)
    @action(detail=False)
    def recent(self, request):
        """URL: /movies/recent/"""
        pass
    
    # 2. Custom URL-Path
    @action(detail=False, url_path='top-10')
    def top_rated(self, request):
        """URL: /movies/top-10/"""
        pass
    
    # 3. Multiple HTTP Methods
    @action(detail=True, methods=['get', 'post', 'delete'])
    def bookmark(self, request, pk=None):
        """
        URL: /movies/{pk}/bookmark/
        GET:    Check if bookmarked
        POST:   Add bookmark
        DELETE: Remove bookmark
        """
        if request.method == 'GET':
            # Check bookmark
            pass
        elif request.method == 'POST':
            # Add bookmark
            pass
        elif request.method == 'DELETE':
            # Remove bookmark
            pass
    
    # 4. Custom Serializer
    @action(
        detail=False,
        serializer_class=MovieStatisticsSerializer
    )
    def statistics(self, request):
        """URL: /movies/statistics/"""
        stats = {
            'total': Movie.objects.count(),
            'avg_rating': Movie.objects.aggregate(Avg('rating'))['rating__avg'],
        }
        serializer = self.get_serializer(stats)
        return Response(serializer.data)
    
    # 5. Custom Permissions
    @action(
        detail=True,
        methods=['post'],
        permission_classes=[IsAdminUser]
    )
    def verify(self, request, pk=None):
        """
        URL: /movies/{pk}/verify/
        Nur für Admins!
        """
        movie = self.get_object()
        movie.is_verified = True
        movie.save()
        return Response({'status': 'verified'})

App 1: Movies

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter
from .views import MovieViewSet, ArtistViewSet

router = DefaultRouter()
router.register(r'movies', MovieViewSet)
router.register(r'artists', ArtistViewSet)

# Kein urlpatterns! Nur router exportieren

App 2: Reviews

# filepath: reviews/urls.py
from rest_framework.routers import DefaultRouter
from .views import ReviewViewSet, CommentViewSet

router = DefaultRouter()
router.register(r'reviews', ReviewViewSet)
router.register(r'comments', CommentViewSet)

Haupt-URLs - Alle kombinieren:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include

# Routers importieren
from movies.urls import router as movies_router
from reviews.urls import router as reviews_router

urlpatterns = [
    path('admin/', admin.site.urls),
    
    # Router URLs einbinden
    path('api/', include(movies_router.urls)),
    path('api/', include(reviews_router.urls)),
    
    # Oder mit Präfix:
    # path('api/movies/', include(movies_router.urls)),
    # path('api/reviews/', include(reviews_router.urls)),
]

Problem: Standard-Routing

# Standard (Flach):
GET /api/movies/1/
GET /api/castings/?movie=1  # ← Nicht ideal

# Gewünscht (Nested):
GET /api/movies/1/
GET /api/movies/1/castings/  # ← Besser!

Lösung: drf-nested-routers installieren

# Installation:
pip install drf-nested-routers

ViewSets:

# filepath: movies/views.py
from rest_framework import viewsets
from .models import Movie, MovieCasting
from .serializers import MovieSerializer, MovieCastingSerializer


class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer


class MovieCastingViewSet(viewsets.ModelViewSet):
    serializer_class = MovieCastingSerializer
    
    def get_queryset(self):
        """Nur Castings des Movies"""
        movie_pk = self.kwargs.get('movie_pk')
        return MovieCasting.objects.filter(movie_id=movie_pk)
    
    def perform_create(self, serializer):
        """Movie automatisch setzen"""
        movie_pk = self.kwargs.get('movie_pk')
        serializer.save(movie_id=movie_pk)

Nested Router Setup:

# filepath: movies/urls.py
from rest_framework_nested import routers
from .views import MovieViewSet, MovieCastingViewSet

# Parent Router
router = routers.DefaultRouter()
router.register(r'movies', MovieViewSet, basename='movie')

# Nested Router
movies_router = routers.NestedDefaultRouter(
    router,           # Parent Router
    r'movies',        # Parent Prefix
    lookup='movie'    # Lookup-Name für {movie_pk}
)
movies_router.register(
    r'castings',      # Nested Prefix
    MovieCastingViewSet,
    basename='movie-castings'
)

# URLs kombinieren
urlpatterns = router.urls + movies_router.urls

1. Versioning in settings.py aktivieren:

# filepath: movieapi/settings.py
REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',
    'DEFAULT_VERSION': 'v1',
    'ALLOWED_VERSIONS': ['v1', 'v2'],
    'VERSION_PARAM': 'version',
}

2. URLs mit Versionen:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include
from movies.urls import router as movies_router_v1
from movies_v2.urls import router as movies_router_v2

urlpatterns = [
    path('admin/', admin.site.urls),
    
    # API v1
    path('api/v1/', include(movies_router_v1.urls)),
    
    # API v2
    path('api/v2/', include(movies_router_v2.urls)),
]

3. Version in View nutzen:

# filepath: movies/views.py
class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    
    def get_serializer_class(self):
        """Serializer basierend auf Version"""
        if self.request.version == 'v1':
            return MovieSerializerV1
        elif self.request.version == 'v2':
            return MovieSerializerV2
        return MovieSerializer

Alternative: Query Parameter Versioning

# settings.py:
REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.QueryParameterVersioning',
}

# URLs:
GET /api/movies/?version=v1
GET /api/movies/?version=v2

Szenario: Router + Custom URLs

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter
from django.urls import path
from .views import MovieViewSet, MovieSearchAPIView, MovieStatsAPIView

# Router für ViewSet
router = DefaultRouter()
router.register(r'movies', MovieViewSet)

# Router URLs + Custom URLs kombinieren
urlpatterns = [
    # Custom URLs (nicht im ViewSet)
    path('movies/search/', MovieSearchAPIView.as_view(), name='movie-search'),
    path('movies/stats/', MovieStatsAPIView.as_view(), name='movie-stats'),
] + router.urls

# WICHTIG: Custom URLs VOR router.urls!
# Sonst matched /movies/search/ als /movies/{pk}/

Alternative: Alles als @action

class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    @action(detail=False, methods=['get'])
    def search(self, request):
        """URL: /movies/search/?q=matrix"""
        query = request.query_params.get('q')
        movies = Movie.objects.filter(title__icontains=query)
        serializer = self.get_serializer(movies, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def stats(self, request):
        """URL: /movies/stats/"""
        stats = {
            'total': Movie.objects.count(),
            'avg_rating': Movie.objects.aggregate(Avg('rating'))['rating__avg']
        }
        return Response(stats)

# URLs:
router = DefaultRouter()
router.register(r'movies', MovieViewSet)
urlpatterns = router.urls  # Fertig!

Standard: Mit Trailing Slash (Django-Style)

GET /api/movies/      ✅
GET /api/movies       ❌ (Redirect zu /api/movies/)

Trailing Slashes deaktivieren:

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter

# Trailing Slashes ausschalten
router = DefaultRouter(trailing_slash=False)
router.register(r'movies', MovieViewSet)

urlpatterns = router.urls

# Jetzt:
GET /api/movies  ✅
GET /api/movies/ ❌

Beides erlauben (Optional):

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter

# Beide Varianten erlauben
router = DefaultRouter()
router.register(r'movies/?', MovieViewSet)  # ← /? macht Slash optional

# Jetzt:
GET /api/movies   ✅
GET /api/movies/  ✅

Beispiel: URL Resolution Tests

# filepath: movies/tests/test_urls.py
from django.test import TestCase
from django.urls import reverse, resolve
from rest_framework.test import APITestCase
from movies.views import MovieViewSet


class MovieURLTest(TestCase):
    """Tests für Movie URLs"""
    
    def test_movie_list_url(self):
        """Test: movie-list URL"""
        url = reverse('movie-list')
        self.assertEqual(url, '/api/movies/')
    
    def test_movie_detail_url(self):
        """Test: movie-detail URL"""
        url = reverse('movie-detail', kwargs={'pk': 1})
        self.assertEqual(url, '/api/movies/1/')
    
    def test_movie_top_rated_url(self):
        """Test: Custom Action URL"""
        url = reverse('movie-top-rated')
        self.assertEqual(url, '/api/movies/top_rated/')
    
    def test_movie_rate_url(self):
        """Test: Member Action URL"""
        url = reverse('movie-rate', kwargs={'pk': 1})
        self.assertEqual(url, '/api/movies/1/rate/')
    
    def test_url_resolves_to_view(self):
        """Test: URL löst zu korrektem ViewSet auf"""
        resolver = resolve('/api/movies/')
        self.assertEqual(resolver.func.cls, MovieViewSet)


class MovieAPITest(APITestCase):
    """Tests für Movie API Endpoints"""
    
    def test_movie_list_endpoint(self):
        """Test: GET /api/movies/"""
        response = self.client.get('/api/movies/')
        self.assertEqual(response.status_code, 200)
    
    def test_movie_detail_endpoint(self):
        """Test: GET /api/movies/1/"""
        # Movie erstellen
        movie = Movie.objects.create(
            title="Matrix",
            year=1999,
            genre="Sci-Fi"
        )
        
        response = self.client.get(f'/api/movies/{movie.pk}/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data['title'], "Matrix")
    
    def test_movie_create_endpoint(self):
        """Test: POST /api/movies/"""
        data = {
            'title': 'Inception',
            'year': 2010,
            'genre': 'Sci-Fi',
            'rating': 8.8
        }
        
        response = self.client.post('/api/movies/', data, format='json')
        self.assertEqual(response.status_code, 201)
        self.assertEqual(Movie.objects.count(), 1)
    
    def test_custom_action_top_rated(self):
        """Test: GET /api/movies/top_rated/"""
        # Test-Daten erstellen
        Movie.objects.create(title="Movie 1", year=2020, rating=9.0)
        Movie.objects.create(title="Movie 2", year=2021, rating=8.5)
        
        response = self.client.get('/api/movies/top_rated/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 2)
    
    def test_url_not_found(self):
        """Test: Nicht existierende URL"""
        response = self.client.get('/api/movies/99999/')
        self.assertEqual(response.status_code, 404)

1. Models (Recap):

# filepath: movies/models.py
from django.db import models

class Movie(models.Model):
    title = models.CharField(max_length=200, unique=True)
    year = models.IntegerField()
    genre = models.CharField(max_length=100)
    rating = models.DecimalField(max_digits=3, decimal_places=1, null=True, blank=True)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return f"{self.title} ({self.year})"


class Artist(models.Model):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    birth_date = models.DateField(null=True, blank=True)
    
    def __str__(self):
        return f"{self.first_name} {self.last_name}"


class MovieCasting(models.Model):
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE, related_name='castings')
    artist = models.ForeignKey(Artist, on_delete=models.CASCADE, related_name='castings')
    role_name = models.CharField(max_length=200)
    is_lead = models.BooleanField(default=False)
    
    def __str__(self):
        return f"{self.artist} as {self.role_name} in {self.movie}"

2. Serializers:

# filepath: movies/serializers.py
from rest_framework import serializers
from .models import Movie, Artist, MovieCasting


class MovieSerializer(serializers.ModelSerializer):
    class Meta:
        model = Movie
        fields = '__all__'
        read_only_fields = ['id', 'created_at', 'updated_at']


class ArtistSerializer(serializers.ModelSerializer):
    class Meta:
        model = Artist
        fields = '__all__'


class MovieCastingSerializer(serializers.ModelSerializer):
    artist_name = serializers.CharField(source='artist.__str__', read_only=True)
    movie_title = serializers.CharField(source='movie.title', read_only=True)
    
    class Meta:
        model = MovieCasting
        fields = '__all__'
        read_only_fields = ['id']

3. ViewSets mit Custom Actions:

# filepath: movies/views.py
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from django.db.models import Avg, Count, Q
from datetime import datetime
from .models import Movie, Artist, MovieCasting
from .serializers import MovieSerializer, ArtistSerializer, MovieCastingSerializer


class MovieViewSet(viewsets.ModelViewSet):
    """
    ViewSet für Movie CRUD + Custom Actions
    """
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    @action(detail=False, methods=['get'])
    def top_rated(self, request):
        """
        Top 10 Filme nach Rating
        URL: GET /api/movies/top_rated/
        """
        top_movies = Movie.objects.filter(
            rating__isnull=False
        ).order_by('-rating')[:10]
        
        serializer = self.get_serializer(top_movies, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def recent(self, request):
        """
        Filme der letzten 5 Jahre
        URL: GET /api/movies/recent/
        """
        current_year = datetime.now().year
        recent_movies = Movie.objects.filter(
            year__gte=current_year - 5
        ).order_by('-year')
        
        serializer = self.get_serializer(recent_movies, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def statistics(self, request):
        """
        Statistiken über alle Filme
        URL: GET /api/movies/statistics/
        """
        stats = Movie.objects.aggregate(
            total=Count('id'),
            avg_rating=Avg('rating'),
            oldest_year=models.Min('year'),
            newest_year=models.Max('year')
        )
        
        stats['by_genre'] = list(
            Movie.objects.values('genre')
            .annotate(count=Count('id'))
            .order_by('-count')
        )
        
        return Response(stats)
    
    @action(detail=False, methods=['get'])
    def search(self, request):
        """
        Filme suchen
        URL: GET /api/movies/search/?q=matrix&year=1999&genre=Sci-Fi
        """
        queryset = Movie.objects.all()
        
        # Query Parameter auslesen
        query = request.query_params.get('q', None)
        year = request.query_params.get('year', None)
        genre = request.query_params.get('genre', None)
        
        # Filtern
        if query:
            queryset = queryset.filter(
                Q(title__icontains=query) | Q(description__icontains=query)
            )
        
        if year:
            queryset = queryset.filter(year=year)
        
        if genre:
            queryset = queryset.filter(genre__iexact=genre)
        
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)
    
    @action(detail=True, methods=['post'])
    def rate(self, request, pk=None):
        """
        Film bewerten
        URL: POST /api/movies/{pk}/rate/
        Body: {"rating": 8.5}
        """
        movie = self.get_object()
        rating = request.data.get('rating')
        
        # Validierung
        try:
            rating = float(rating)
            if not (0 <= rating <= 10):
                return Response(
                    {'error': 'Rating must be between 0 and 10'},
                    status=status.HTTP_400_BAD_REQUEST
                )
        except (TypeError, ValueError):
            return Response(
                {'error': 'Invalid rating value'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        # Speichern
        movie.rating = rating
        movie.save()
        
        serializer = self.get_serializer(movie)
        return Response(serializer.data)
    
    @action(detail=True, methods=['get'])
    def cast(self, request, pk=None):
        """
        Besetzung eines Films
        URL: GET /api/movies/{pk}/cast/
        """
        movie = self.get_object()
        castings = movie.castings.select_related('artist').all()
        
        serializer = MovieCastingSerializer(castings, many=True)
        return Response(serializer.data)


class ArtistViewSet(viewsets.ModelViewSet):
    """
    ViewSet für Artist CRUD + Custom Actions
    """
    queryset = Artist.objects.all()
    serializer_class = ArtistSerializer
    
    @action(detail=True, methods=['get'])
    def movies(self, request, pk=None):
        """
        Alle Filme eines Artists
        URL: GET /api/artists/{pk}/movies/
        """
        artist = self.get_object()
        castings = artist.castings.select_related('movie').all()
        
        # Unique Movies extrahieren
        movies = list(set([casting.movie for casting in castings]))
        
        serializer = MovieSerializer(movies, many=True)
        return Response(serializer.data)


class MovieCastingViewSet(viewsets.ModelViewSet):
    """
    ViewSet für MovieCasting CRUD
    """
    queryset = MovieCasting.objects.select_related('movie', 'artist').all()
    serializer_class = MovieCastingSerializer
    
    @action(detail=False, methods=['get'])
    def lead_roles(self, request):
        """
        Alle Hauptrollen
        URL: GET /api/castings/lead_roles/
        """
        lead_castings = MovieCasting.objects.filter(
            is_lead=True
        ).select_related('movie', 'artist')
        
        serializer = self.get_serializer(lead_castings, many=True)
        return Response(serializer.data)

4. App URLs - Router Setup:

# filepath: movies/urls.py
from rest_framework.routers import DefaultRouter
from .views import MovieViewSet, ArtistViewSet, MovieCastingViewSet

# Router erstellen
router = DefaultRouter()

# ViewSets registrieren
router.register(r'movies', MovieViewSet, basename='movie')
router.register(r'artists', ArtistViewSet, basename='artist')
router.register(r'castings', MovieCastingViewSet, basename='casting')

# URLs exportieren
urlpatterns = router.urls

5. Haupt-URLs - Integration:

# filepath: movieapi/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    # Django Admin
    path('admin/', admin.site.urls),
    
    # API URLs
    path('api/', include('movies.urls')),
    
    # DRF Auth (Login/Logout für Browsable API)
    path('api-auth/', include('rest_framework.urls')),
]

6. Settings - DRF Konfiguration:

# filepath: movieapi/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    # DRF
    'rest_framework',
    
    # Apps
    'movies',
]

REST_FRAMEWORK = {
    # Pagination
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10,
    
    # Filtering
    'DEFAULT_FILTER_BACKENDS': [
        'rest_framework.filters.OrderingFilter',
        'rest_framework.filters.SearchFilter',
    ],
    
    # Permissions (optional)
    # 'DEFAULT_PERMISSION_CLASSES': [
    #     'rest_framework.permissions.IsAuthenticatedOrReadOnly',
    # ],
}

1. Django Shell - Alle URLs anzeigen:

python manage.py shell

>>> from django.urls import get_resolver
>>> resolver = get_resolver()
>>> for pattern in resolver.url_patterns:
...     print(pattern)

# Oder spezifischer:
>>> from rest_framework.routers import DefaultRouter
>>> from movies.urls import router
>>> for url in router.urls:
...     print(url.pattern)

2. Management Command - URLs ausgeben:

# Django 3.0+:
python manage.py show_urls

# Output:
/api/                              → api-root
/api/movies/                       → movie-list
/api/movies/{pk}/                  → movie-detail
/api/movies/top_rated/             → movie-top-rated
...

3. Browsable API - Root View:

# Browser öffnen:
http://localhost:8000/api/

# DefaultRouter zeigt automatisch alle Endpoints!

4. Custom Management Command erstellen:

# filepath: movies/management/commands/list_urls.py
from django.core.management.base import BaseCommand
from django.urls import get_resolver


class Command(BaseCommand):
    help = 'Liste alle URLs'
    
    def handle(self, *args, **options):
        resolver = get_resolver()
        
        def show_urls(urllist, depth=0):
            for entry in urllist:
                print("  " * depth + str(entry.pattern))
                if hasattr(entry, 'url_patterns'):
                    show_urls(entry.url_patterns, depth + 1)
        
        show_urls(resolver.url_patterns)

# Verwendung:
python manage.py list_urls

5. django-extensions installieren:

# Installation:
pip install django-extensions

# settings.py:
INSTALLED_APPS = [
    # ...
    'django_extensions',
]

# Alle URLs anzeigen:
python manage.py show_urls

# Mit Details:
python manage.py show_urls --format table